package com.nicho.controller;

import java.util.Scanner;

import com.nicho.pojo.Course;
import com.nicho.pojo.SRoot;
import com.nicho.pojo.Student;
import com.nicho.pojo.Teacher;
import com.nicho.service.SRootService;
import com.nicho.util.InputTrans;
import com.nicho.util.MD5;
import com.nicho.view.SRootPage;

/*
 * @Author: 姜东浩
 * @Date: 2021-11-10 6:50:04
 * @LastEditors: 姜东浩
 * @LastEditTime: 2021-11-10 15:50:04
 * @Description: 管理员控制器
 */
public class SRootController {

    Scanner sc = new Scanner(System.in);
    SRoot sRoot = null;
    SRootService sRootService = new SRootService();

    /**
     * @description:登录
     * @param userId   管理员ID
     * @param password 管理员密码
     * @author: 姜东浩
     */
    public void login(String userId, String password) {

        // 将传进来的账号密码封装为一个管理员对象
        sRoot = new SRoot(userId, password);

        // 登录成功显示首页视图，否则提示登陆失败
        if (sRootService.sRootLogin(sRoot) != null) {
            SRootPage.showLoginSuccess();
        } else {
            System.out.println("登录失败");
        }

    }

    /**
     * @description: 向数据库中添加一名学生
     * @return 添加操作结束后的提示信息
     * @author: 姜东浩
     */
    public String insertOneStudent() {

        System.out.print("请输入学生账号（纯数字）：");
        // 去除用户输入字符串两端的空格
        String studentId = sc.next().trim();
        if (!("s".equals(InputTrans.judgeTR(studentId)))) {
            return "学号类型与规定的学生学号类型不符";
        }

        System.out.print("请输入学生姓名：");
        // 去除用户输入字符串两端的空格
        String studentName = sc.next().trim();

        System.out.print("请输入学生性别（M/W）：");
        // 去除用户输入字符串两端的空格
        String studentSex = sc.next().trim();
        if (!InputTrans.judgeWM(studentSex)) {
            return "性别类型与规定的类型不符";
        }

        // 将用户输入封装为一个学生对象，密码默认为000000
        Student student = new Student(studentId, studentName, MD5.md5("000000"), studentSex);

        // 如果没有此学号的学生，则进行添加操作，否则添加失败，返回失败信息
        if (sRootService.existStudent(student) == null) {
            return sRootService.insertOneStudent(student);
        } else {
            return "学号已存在,添加失败!";
        }

    }

    /**
     * @description: 删除一名学生
     * @return 删除操作结束后的提示信息
     * @author: 姜东浩
     */
    public String deleteOneStudent() {

        System.out.print("请输入学生账号：");
        // 去除用户输入字符串两端的空格
        String studentId = sc.next().trim();
        if (!("s".equals(InputTrans.judgeTR(studentId)))) {
            return "学号类型与规定的学生学号类型不符";
        }

        // 将用户输入封装为一个学生对象
        Student student = new Student();
        student.setStudentId(studentId);

        // 查看文件中是否有此学号学生
        if (sRootService.existStudent(student) == null) {
            return "没有此学号学生!";
        }

        // 进行删除操作，否则删除失败，返回失败信息
        return sRootService.deleteOneStudent(sRootService.existStudent(student));

    }

    /**
     * @description: 修改学生密码
     * @return 修改操作结束后的提示信息
     * @author: 姜东浩
     */
    public String changeStudentPwd() {

        System.out.print("请输入学生账号：");
        // 去除用户输入字符串两端的空格
        String studentId = sc.next().trim();
        if (!("s".equals(InputTrans.judgeTR(studentId)))) {
            return "学号类型与规定的学生学号类型不符";
        }

        // 将用户输入封装为一个学生对象
        Student student = new Student();
        student.setStudentId(studentId);

        // 查看文件中是否有此学号学生
        if (sRootService.existStudent(student) == null) {
            return "没有此学号学生!";
        }

        System.out.print("请输入修改后的密码：");
        // 修改密码，管理员修改，只输入一遍即可，不需要二次验证
        return sRootService.changeStudentPwd(studentId, MD5.md5(sc.next()));

    }

    /**
     * @description: （全部信息）显示所有学生信息列表
     * @author: 姜东浩
     */
    public void showALlStudents() {
        (sRootService.showALlStudents()).forEach(System.out::println);
    }

    /**
     * @description: （重要信息）显示所有学生信息列表
     * @author: 姜东浩
     */
    public void showALlStudentsE() {

        String str = "课程集合[ ";
        for(int i=0;i<sRootService.showALlStudents().size(); i++){
            for(int j=0;j<sRootService.showALlStudents().get(i).getsCourseList().size();j++){
                str += "[课程名：" +
                sRootService.showALlStudents().get(i).getsCourseList().get(j).getCourseName()
                +", 授课教师名："
                + sRootService.showALlStudents().get(i).getsCourseList().get(j).getcTeacher().getTeacherName()
                +", 成绩："
                +sRootService.showALlStudents().get(i).getsCourseList().get(j).getGrade()
                +"] "
                ;
            }
           System.out.println(sRootService.showALlStudents().get(i).toStringR() + ", " + str + "]");
           str = "课程集合[ ";
        }

    }

    // ========================================================================================================================
    /**
     * @description: 添加一名教师
     * @return 添加操作后的提示信息
     * @author: 姜东浩
     */
    public String insertOneTeacher() {

        System.out.print("请输入教师账号：");
        // 去除用户输入字符串两端的空格
        String teacherId = sc.next().trim();
        if (!("t".equals(InputTrans.judgeTR(teacherId)))) {
            return "ID类型与规定的教师类型不符";
        }

        System.out.print("请输入教师姓名：");
        // 去除用户输入字符串两端的空格
        String teacherName = sc.next().trim();

        System.out.print("请输入教师性别（M/W）：");
        // 去除用户输入字符串两端的空格
        String teacherSex = sc.next().trim();
        if (!InputTrans.judgeWM(teacherSex)) {
            return "性别类型与规定的类型不符";
        }

        // 将用户输入封装为一位教师对象，初始密码为000000
        Teacher teacher = new Teacher(teacherId, teacherName, MD5.md5("000000"), teacherSex);

        // 如果文件中没有此ID的教师，则进行添加操作，否则添加失败，返回失败信息
        if (sRootService.existTeacher(teacher) == null) {
            return sRootService.insertOneTeacher(teacher);
        } else {
            return "ID已存在,添加失败!";
        }

    }

    /**
     * @description: 删除一位教师
     * @return 删除操作结束后返回的提示信息
     * @author: 姜东浩
     */
    public String deleteOneTeacher() {

        System.out.print("请输入教师账号：");
        // 去除用户输入字符串两端的空格
        String teacherId = sc.next().trim();
        if (!("t".equals(InputTrans.judgeTR(teacherId)))) {
            return "ID类型与规定的教师类型不符";
        }

        // 将用户输入封装为一位教师对象
        Teacher teacher = new Teacher();
        teacher.setTeacherId(teacherId);

        // 查看文件中是否有此ID教师
        if (sRootService.existTeacher(teacher) == null) {
            return "没有此ID教师!";
        }

        // 进行删除操作
        return sRootService.deleteOneTeacher(sRootService.existTeacher(teacher));

    }

    /**
     * @description: 设置一名老师教一门课程
     * @return 返回操作后的提示
     * @author: 姜东浩
     */    
    public String toTeachOneCourse(){

        System.out.print("请输入教师账号：");
        // 去除用户输入字符串两端的空格
        String teacherId = sc.next().trim();
        if (!("t".equals(InputTrans.judgeTR(teacherId)))) {
            return "ID类型与规定的教师类型不符";
        }

        // 将用户输入封装为一位教师对象
        Teacher teacher = new Teacher();
        teacher.setTeacherId(teacherId);

        // 查看文件中是否有此ID教师
        if (sRootService.existTeacher(teacher) == null) {
            return "没有此ID教师!";
        }

        System.out.print("请输入课程ID：");
        // 去除用户输入字符串两端的空格
        String courseId = sc.next().trim();
        if (!("b".equals(InputTrans.judgeBX(courseId)) || "x".equals(InputTrans.judgeBX(courseId)))) {
            return "ID类型与规定的课程类型不符";
        }
      
        // 判断有没有这个ID对应的这门课
        if(sRootService.existCourseById(courseId)==null){
            return "没有此ID的课程";
        }

        return sRootService.toTeachOneCourse(sRootService.existTeacher(teacher), sRootService.existCourseById(courseId));

    }

    /**
     * @description: 修改教师密码
     * @return 修改操作结束后的提示信息
     * @author: 姜东浩
     */
    public String changeTeacherPwd() {

        System.out.print("请输入教师账号：");
        // 去除用户输入字符串两端的空格
        String teacherId = sc.next().trim();
        if (!("t".equals(InputTrans.judgeTR(teacherId)))) {
            return "ID类型与规定的教师类型不符";
        }

        // 将用户输入信息封装为一位教师对象
        Teacher teacher = new Teacher();
        teacher.setTeacherId(teacherId);

        // 查看文件中是否有此ID的教师，返回1说明有，否则没有
        if (sRootService.existTeacher(teacher) == null) {
            return "没有此ID教师!";
        }

        System.out.print("请输入修改后的密码：");
        // 修改密码
        return sRootService.changeTeacherPwd(teacherId, MD5.md5(sc.next()));

    }

    /**
     * @description: （全部信息）显示所有教师信息列表
     * @author: 姜东浩
     */
    public void showALlTeachers() {

        (sRootService.showALlTeachers()).forEach(System.out::println);

    }

    /**
     * @description: （重要信息）显示所有教师信息列表
     * @author: 姜东浩
     */
    public void showAllTeachersE(){

        for(int i=0;i<sRootService.showALlTeachers().size(); i++){
           System.out.println(sRootService.showALlTeachers().get(i).toStringE());
        }

    }

    // ========================================================================================================================
    /**
     * @description: 添加一门课程
     * @return 返回添加后提示信息
     * @author: 姜东浩
     */
    public String insertOneCourse() {

        System.out.print("请输入课程ID：");
        // 去除用户输入字符串两端的空格
        String courseId = sc.next().trim();
        if (!("b".equals(InputTrans.judgeBX(courseId)) || "x".equals(InputTrans.judgeBX(courseId)))) {
            return "ID类型与规定的课程类型不符";
        }

        System.out.print("请输入课程名：");
        // 去除用户输入字符串两端的空格
        String courseName = sc.next().trim();

        System.out.print("请输入课程讲师ID：");
        String teacherId = sc.next().trim();
        if (!("t".equals(InputTrans.judgeTR(teacherId)))) {
            return "ID类型与规定的教师类型不符";
        }

        // 将用户输入封装为一位教师对象
        Teacher teacher = new Teacher();
        teacher.setTeacherId(teacherId);

        // 查看文件中是否有此ID教师
        if (sRootService.existTeacher(teacher) == null) {
            return "没有此ID教师!";
        }
        teacher = sRootService.existTeacher(teacher);
        teacher.settCourseId(courseId);

        System.out.print("请输入课程可报人数（int）");
        int snum = InputTrans.transitionToInt(sc.next());
        if (snum == -1) {
            return "人数输入有误";
        }

        Course course = new Course(courseId, courseName, snum, teacher);

        return sRootService.insertOneCourse(course);

    }

    /**
     * @description: 移除一门课程
     * @author: 姜东浩
     */    
    public String removeOneCourse(){

        System.out.print("请输入课程ID：");
        // 去除用户输入字符串两端的空格
        String courseId = sc.next().trim();
        if (!("b".equals(InputTrans.judgeBX(courseId)) || "x".equals(InputTrans.judgeBX(courseId)))) {
            return "ID类型与规定的课程类型不符";
        }

        // 判断有没有这个ID对应的这门课
        if(sRootService.existCourseById(courseId)==null){
            return "没有此ID的课程";
        }

        // 进行删除操作
        return sRootService.removeOneCourse(sRootService.existCourseById(courseId));

    }

    /**
     * @description: （全部信息）显示所有课程信息列表
     * @author: 姜东浩
     */
    public void showALlCourses() {

        (sRootService.showALlCourses()).forEach(System.out::println);

    }

    /**
     * @description: （重要信息）显示所有课程信息列表
     * @author: 姜东浩
     */
    public void showALlCoursesE() {

        for(int i= 0;i<sRootService.showALlCourses().size();i++){
            System.out.println(sRootService.showALlCourses().get(i).toStringR());
        }

    }

    // ========================================================================================================================
    /**
     * @description: 修改自己密码
     * @return 修改操作结束后的提示信息
     * @author: 姜东浩
     */
    public void changeMyPwd() {

        System.out.print("请输入修改后的密码：");
        if (sRootService.changeMyPwd(MD5.md5(sc.next())) == 1) {
            System.out.println("修改此账户密码成功,请重新登陆!");
            // 修改成功后，系统退出，需要重新登陆
            System.exit(0);
        } else {
            System.out.println("修改此账户密码失败!");
        }

    }

}